Types

Core types and structures used in PVAC-HFHE

Overview

This module defines the fundamental types, structures, and enumerations used throughout PVAC-HFHE, including cryptographic keys, ciphertexts, parameters, and graph structures for homomorphic operations.

Structures

Params

Parameters controlling the security and performance of the PVAC-HFHE scheme.

struct Params {
    int B = 337;
    int m_bits = 8192;
    int n_bits = 16384;
    int h_col_wt = 192;
    int x_col_wt = 128;
    int err_wt = 128;
    double noise_entropy_bits = 120.0;
    double tuple2_fraction = 0.55;
    double depth_slope_bits = 16.0;
    size_t edge_budget = 1200000;
    int lpn_n = 4096;
    int lpn_t = 16384;
    int lpn_tau_num = 1;
    int lpn_tau_den = 8;
    double recrypt_lo = 0.48;
    double recrypt_hi = 0.52;
    int recrypt_rounds = 8;
};

B · int · default: "337"

Multiplicative group carrier for homomorphic properties

m_bits · int · default: "8192"

Dimension parameter m in bits

n_bits · int · default: "16384"

Dimension parameter n in bits

h_col_wt · int · default: "192"

Column weight for H matrix

x_col_wt · int · default: "128"

Column weight for x matrix

err_wt · int · default: "128"

Error weight parameter

noise_entropy_bits · double · default: "120.0"

Noise entropy in bits for security

tuple2_fraction · double · default: "0.55"

Fraction parameter for tuple generation

depth_slope_bits · double · default: "16.0"

Depth slope parameter in bits

edge_budget · size_t · default: "1200000"

Maximum number of edges in computation graph

lpn_n · int · default: "4096"

LPN dimension parameter

lpn_t · int · default: "16384"

LPN sample count parameter

lpn_tau_num · int · default: "1"

LPN noise rate numerator (τ = lpn_tau_num / lpn_tau_den)

lpn_tau_den · int · default: "8"

LPN noise rate denominator (τ = 1/8)

recrypt_lo · double · default: "0.48"

Lower bound for recryption threshold

recrypt_hi · double · default: "0.52"

Upper bound for recryption threshold

recrypt_rounds · int · default: "8"

Number of recryption rounds

The default parameters provide:

• Information-theoretic security: 2226 bits
• Classical security: 200+ bits
• Quantum security: 100+ bits

Fp

Field element represented as a 127-bit integer using two 64-bit words.

struct Fp {
    uint64_t lo;
    uint64_t hi;
};

lo · uint64_t

Low 64 bits of the field element

hi · uint64_t

High 63 bits of the field element (top bit unused)

Fp represents elements in the field modulo 2^127 - 1 (Mersenne prime p = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF).

PubKey

Public key for encryption and evaluation.

struct PubKey {
    Params prm;
    uint64_t canon_tag;
    std::vector<BitVec> H;
    Ubk ubk;
    std::array<uint8_t, 32> H_digest;
    Fp omega_B;
    std::vector<Fp> powg_B;
};

prm · Params

Scheme parameters

canon_tag · uint64_t

Canonical tag for key identification

H · std::vector<BitVec>

Public matrix H for LPN-based encryption

ubk · Ubk

Permutation data for universal broadcast

H_digest · std::array<uint8_t, 32>

SHA-256 digest of matrix H

omega_B · Fp

B-th root of unity in the field

powg_B · std::vector<Fp>

Precomputed powers for evaluation

SecKey

Secret key for decryption.

struct SecKey {
    std::array<uint64_t, 4> prf_k;
    std::vector<uint64_t> lpn_s_bits;
};

prf_k · std::array<uint64_t, 4>

PRF key for pseudorandom generation (256 bits)

lpn_s_bits · std::vector<uint64_t>

LPN secret vector in packed bit format

Cipher

Ciphertext structure representing encrypted data and computation graph.

struct Cipher {
    std::vector<Layer> L;
    std::vector<Edge> E;
    std::vector<Fp> c0;
    size_t slots = 1;
};

L · std::vector<Layer>

Computation layers in the DAG

E · std::vector<Edge>

Edges connecting layers in the computation graph

c0 · std::vector<Fp>

Base ciphertext vector

slots · size_t · default: "1"

Number of message slots (for batching)

Layer

Computation layer in the evaluation graph.

struct Layer {
    RRule rule;
    RSeed seed;
    uint32_t pa;
    uint32_t pb;
};

rule · RRule

Computation rule type (BASE or PROD)

seed · RSeed

Random seed for deterministic randomness expansion

pa · uint32_t

Parent index A

pb · uint32_t

Parent index B

Edge

Edge in the computation graph with associated weights.

struct Edge {
    uint32_t layer_id;
    uint16_t idx;
    uint8_t ch;
    std::vector<Fp> w;
    BitVec s;
};

layer_id · uint32_t

Index of the layer this edge connects to

idx · uint16_t

Edge index within the layer

ch · uint8_t

Sign/channel indicator (SGN_P or SGN_M)

w · std::vector<Fp>

Weight vector in the field

s · BitVec

Binary selection vector

EvalKey

Evaluation key for homomorphic operations.

struct EvalKey {
    std::vector<Cipher> zero_pool;
    Cipher enc_one;
};

zero_pool · std::vector<Cipher>

Pool of zero encryptions for noise refreshing

enc_one · Cipher

Encryption of the value 1

Nonce128

128-bit nonce for randomization.

struct Nonce128 {
    uint64_t lo;
    uint64_t hi;
};

lo · uint64_t

Low 64 bits

hi · uint64_t

High 64 bits

RSeed

Random seed structure.

struct RSeed {
    uint64_t ztag;
    Nonce128 nonce;
};

ztag · uint64_t

Tag for domain separation

nonce · Nonce128

128-bit nonce

Ubk

Permutation data for universal broadcast key.

struct Ubk {
    std::vector<int> perm;
    std::vector<int> inv;
};

perm · std::vector<int>

Permutation array

inv · std::vector<int>

Inverse permutation array

Enumerations

RRule

Computation rule type for layers.

enum class RRule : uint8_t {
    BASE = 0,
    PROD = 1
};

BASE · 0

Base layer (input)

PROD · 1

Product layer (multiplication)

EdgeSign

Sign indicator for edges.

enum EdgeSign : uint8_t {
    SGN_P = 0,
    SGN_M = 1
};

SGN_P · 0

Positive sign

SGN_M · 1

Negative sign (minus)

Functions

make_nonce128

Generates a random 128-bit nonce.

Nonce128 make_nonce128();

return · Nonce128

Cryptographically secure random nonce

sgn_val

Converts edge sign to integer value.

int sgn_val(uint8_t ch);

ch · uint8_t

Edge sign (SGN_P or SGN_M)

return · int

Returns +1 for SGN_P, -1 for SGN_M

rand_fp_nonzero

Generates a random non-zero field element.

Fp rand_fp_nonzero();

return · Fp

Random non-zero field element

This function loops until a non-zero element is generated.

Domain Separation Constants

The Dom namespace provides string constants for domain separation in cryptographic operations:

namespace Dom {
    inline constexpr const char* H_GEN = "pvac.dom.h_gen";
    inline constexpr const char* X_SEED = "pvac.dom.x_seed";
    inline constexpr const char* NOISE = "pvac.dom.noise";
    inline constexpr const char* PRF_LPN = "pvac.dom.prf_lpn";
    inline constexpr const char* TOEP = "pvac.dom.toeplitz";
    inline constexpr const char* ZTAG = "pvac.dom.ztag";
    inline constexpr const char* COMMIT = "pvac.dom.commit";
    inline constexpr const char* PRF_R1 = "pvac.prf.r.1";
    inline constexpr const char* PRF_R2 = "pvac.prf.r.2";
    inline constexpr const char* PRF_R3 = "pvac.prf.r.3";
    inline constexpr const char* PRF_NOISE1 = "pvac.prf.noise.1";
    inline constexpr const char* PRF_NOISE2 = "pvac.prf.noise.2";
    inline constexpr const char* PRF_NOISE3 = "pvac.prf.noise.3";
}

These domain separation constants are critical for security. Never modify them unless you fully understand the cryptographic implications.

Related

• Field operations
• BitVec operations
• Random generation